
/**
 * 正则验证与判断方法封装处理
 * 包旭慧 24/4/24
 */
import { methodGetApi } from '@/api/publicApi'
import { sentencedEmpty } from '@/utils/commonUtils/HLUtils'
/**
 * @description: 路由判断
 * @Author: baoxuhui
 * @param {*} path 判断的路径
 * @return {*}
 */
export function isExternal(path) {
  return /^(https?:|mailto:|tel:)/.test(path)
}

/**
 * @description: 判断是否为数字
 * @Author: baoxuhui
 * @param {*} value  判断的值
 * @return {*}
 */
export function isNumber(value) {
  const reg = /^[0-9]*$/
  return reg.test(value)
}

/**
 * @description: 判断是否是名称（匹配中文，英文字母和数字及_）
 * @Author: baoxuhui
 * @param {*} value  判断的值
 * @return {*}
 */
export function isName(value) {
  const reg = /^[\u4e00-\u9fa5a-zA-Z0-9]+$/
  return reg.test(value)
}

/**
 * @description: 判断是否为IP
 * @Author: baoxuhui
 * @param {*} ip  判断的值
 * @return {*}
 */
export function isIP(ip) {
  const reg = /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/
  return reg.test(ip)
}
/**
 * @description: 判断是否是传统网站
 * @Author: baoxuhui
 * @param {*} url  判断的值
 * @return {*}
 */
export function isUrl(url) {
  const reg = /^(https?|ftp):\/\/([a-zA-Z0-9.-]+(:[a-zA-Z0-9.&%$-]+)*@)*((25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9]?[0-9])){3}|([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{2}))(:[0-9]+)*(\/($|[a-zA-Z0-9.,?'\\+&%$#=~_-]+))*$/
  return reg.test(url)
}

/**
 * @description: 判断是否是小写字母
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isLowerCase(str) {
  const reg = /^[a-z]+$/
  return reg.test(str)
}

/**
 * @description: 判断是否是大写字母
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isUpperCase(str) {
  const reg = /^[A-Z]+$/
  return reg.test(str)
}
/**
 * @description: 判断是否是大写字母开头
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isAlphabets(str) {
  const reg = /^[A-Za-z]+$/
  return reg.test(str)
}

/**
 * @description:  判断是否是字符串
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isString(str) {
  return typeof str === 'string' || str instanceof String
}

/**
 * @description: 判断是否是数组
 * @Author: baoxuhui
 * @param {*} arg  判断的值
 * @return {*}
 */
export function isArray(arg) {
  if (typeof Array.isArray === 'undefined') {
    return Object.prototype.toString.call(arg) === '[object Array]'
  }
  return Array.isArray(arg)
}

/**
 * @description: 判断是否是端口号
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isPort(str) {
  const reg = /^([0-9]|[1-9]\d|[1-9]\d{2}|[1-9]\d{3}|[1-5]\d{4}|6[0-4]\d{3}|65[0-4]\d{2}|655[0-2]\d|6553[0-5])$/
  return reg.test(str)
}

/**
 * @description: 判断是否中文
 * @Author: baoxuhui
 * @param {*} str  判断的值
 * @return {*}
 */
export function isChina(str) {
  const reg = /^[\u4E00-\u9FA5]{2,4}$/
  return reg.test(str)
}

/**
 * @description: 正则验证公共调取函数
 * @Author: baoxuhui
 * @param {*} rule
 * @param {*} value
 * @param {*} callback
 * @param {*} type//哪一类的验证  身份证号：idCard，社会统一信用代码:creditCode，固话号:tel，手机号:phone，电话号（包含固话与手机号）:telephone，传真:faxes，邮箱：email，邮政编码:postalCode，银行卡号:bankCard
 * @param {*} onlyBool//是否唯一  默认非唯一
 * @param {*} url//是唯一调取接口路径
 * @param {*} params//是唯一调取接口入参
 * @return {*}
 */
export function regularFun(rule, value, callback, type, onlyBool, url, params) {
  let typeverify
  if (type === 'idCard') {
    // 身份证号正则
    typeverify = /^[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/
  } else if (type === 'creditCode') {
    // 社会统一信用代码
    typeverify = /^[\dA-Z]{18}$/
  } else if (type === 'tel') {
    // 固话号
    typeverify = /^(400|800)([0-9\\-]{7,10})|(([0-9]{4}|[0-9]{3})(-| )?)?([0-9]{7,8})((-| |转)*([0-9]{1,4}))?$/
  } else if (type === 'phone') {
    // 手机号
    typeverify = /^1([3-9][0-9]|4[579]|5[0-3,5-9]|6[6]|7[0135678]|9[89])\d{8}$/
  } else if (type === 'telephone') {
    // 电话号（包含固话与手机号）
    typeverify = /^((0\d{2,3}(-)?\d{7,8})|(13[0-9]|14[01456879]|15[0-35-9]|16[2567]|17[0-8]|18[0-9]|19[0-35-9])\d{8})$/
  } else if (type === 'faxes') {
    // 传真
    typeverify = /^(\d{3,4}-)?\d{7,8}$/
  } else if (type === 'email') {
    // 邮箱
    typeverify = /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/
  } else if (type === 'postalCode') {
    // 邮政编码
    typeverify = /^[0-9]\d{5}(?!\d)$/
  } else if (type === 'bankCard') {
    // 银行卡号
    // typeverify = /^[A-Z]{4}([A-Z0-9]{4,7})$/
    typeverify = /^\d{13,21}$/
  }
  if (sentencedEmpty(value)) {
    if (sentencedEmpty(onlyBool)) {
      methodGetApi(url, params).then(res => {
        if (res.data === 0) {
          callback(new Error(res.msg))
        } else {
          callback()
        }
      })
    } else {
      if (!(typeverify.test(value))) {
        callback(new Error('' + rule.msg + '格式不正确，请重新填写'))
      } else {
        callback()
      }
    }
  } else {
    if (rule.required) {
      callback(new Error('请输入' + rule.msg))
    } else {
      callback()
    }
  }
}

/**
 * @description: 判断是密码是否合格
 * @Author: baoxuhui
 * @param {*} rule
 * @param {*} value
 * @param {*} callback
 * @return {*}
 */
export function isPass(rule, value, callback) {
  if (sentencedEmpty(value)) {
    if (!(/^(?=.*[0-9])(?=.*[A-Z])(?=.*[a-z])(?=.*[!@#$%^&*,\._])[0-9a-zA-Z!@#$%^&*,\\._]{8,20}$/.test(value))) {
      callback(new Error('密码必须包含大小写字母,特殊字符和数字，且长度不低于8位,不高于20位'))
    } else {
      callback()
    }
  } else {
    callback(new Error('请输入密码'))
  }
}

/**
 * @description: 判断数组必填
 * @Author: baoxuhui
 * @param {*} rule
 * @param {*} value
 * @param {*} callback
 * @param {*} count
 * @param {*} countName
 * @return {*}
 */
export function numberArrayFun(rule, value, callback,count,countName) {
  console.log(value)
  if (rule.required){
    if (value.length != 0){
      if (value.length>=count) {
        callback()
      } else {
        callback(new Error(`请至少选择${countName}${rule.msg}`))
      }
    } else {
      callback(new Error(`请选择${rule.msg}`))
    }
  } else {
    callback()
  }
}

/**
 * @description: 数字 比大小
 * @Author: baoxuhui
 * @param {*} rule
 * @param {*} value
 * @param {*} callback
 * @param {*} precondition 前提条件
 * @param {*} preconditionName 前提条件文字内容
 * @param {*} count 对比数字
 * @param {*} countName 对比的字段名称
 * @param {*} compareTypeName 比较类型
 * @return {*}
 */
export function numberWarFun(rule, value, callback, precondition,preconditionName,count,countName,compareTypeName,) {
  console.log(value)
  if (rule.required) {
    if (precondition) {
      if (sentencedEmpty(value)) {
        if(compareTypeName == 'big'){
          if (value <= count) {
            callback()
          } else {
            callback(new Error(`${rule.msg}不得大于${countName}`))
          }
        } else if (compareTypeName == 'samll'){
          if (value >= count) {
            callback()
          } else {
            callback(new Error(`${rule.msg}不得小于${countName}`))
          }
        }
      } else {
        callback(new Error(`请输入${rule.msg}`))
      }
    } else {
      callback(new Error(`${preconditionName}`))
    }
  } else {
    callback()
  }
}


/**
 * @description: // 时间组件区间取值规定
 * @Author: baoxuhui
 * @param { Object } rule
 * @param { String } value
 * @param { Function } callback
 * @param { Boolean } timeTestBool 是否打开 前后时间的判断处理  默认 false == 时间判断 是否必填  true == 时间前后判断 及必填处理
 * @param { Object } item 包含值的对象 obj
 * @param { String } type 开始时间：start,结束时间：end
 * @param { String } startLable 开始时间展示Lable
 * @param { String } startLableKey 开始时间在对象中的key
 * @param { String } endLable 结束时间展示Lable
 * @param { String } endLableKey 结束时间在对象中的key
 * @return {*}
 */
export function timeValidateFun(rule, value, callback, timeTestBool = false, item, type, startLable, startLableKey, endLable, endLableKey) {
  const startTime = item[startLableKey]
  const endTime = item[endLableKey]
  if (timeTestBool) {
    comptimeStartEnd(rule, value, callback, startTime, endTime, startLable, startLableKey, endLable, endLableKey, type)
  } else {
    comptimeRequired(rule, value, callback)
  }

}
/**
 * @description: 时间判断 是否必填
 * @Author: baoxuhui
 * @param { Object } rule
 * @param { String } value
 * @param { Function } callback
 * @return {*}
 */
export function comptimeRequired(rule, value, callback) {
   if (rule.required) {
      if (value) {
        callback()
      } else {
        callback(new Error(`请选择${rule.msg}`))
      }
   } else {
      callback()
   }
}
/**
 * @description: 开始时间判断
 * @Author: baoxuhui
 * @param { Object } rule
 * @param { String } value
 * @param { Function } callback
 * @param { String } startTime 开始值
 * @param { String } endTime  结束值
 * @param { String } startLable 开始时间展示Lable
 * @param { String } startLableKey 开始时间在对象中的key
 * @param { String } endLable 结束时间展示Lable
 * @param { String } endLableKey 结束时间在对象中的key
 * @param { String } type 开始时间：start,结束时间：end
 * @return {*}
 */
export function comptimeStartEnd(rule, value, callback, startTime, endTime, startLable, startLableKey, endLable, endLableKey, type) {
  if (rule.required) {
    if (type == 'start') {
      // 判断开始时间 是否 大于 结束时间
      if (startTime) {
        if (endTime) {
          var a = (Date.parse(startTime) - Date.parse(endTime)) / 3600 / 1000
          if (a > 0) {
            callback(new Error(`${startLable}必须小于${endLable}`))
          } else {
            callback()
          }
        } else {
          callback(new Error(`请选择${endLable}`))
        }
      } else {
        callback(new Error(`请选择${startLable}`))
      }
    } else {
      // 判断结束时间 是否 小于 开始时间
      if (endTime) {
        if (startTime) {
          var a = (Date.parse(endTime) - Date.parse(startTime)) / 3600 / 1000
          if (a < 0) {
            callback(new Error(`${endLable}必须大于${startLable}`))
          } else {
            callback()
          }
        } else {
          callback(new Error(`请选择${startLable}`))
        }
      } else {
        callback(new Error(`请选择${endLable}`))
      }
    }
  } else {
    if (type == 'start') {
      if (startTime) {
        if (endTime) {
          var a = (Date.parse(startTime) - Date.parse(endTime)) / 3600 / 1000
          if (a > 0) {
            callback(new Error(`${startLable}必须小于${endLable}`))
          } else {
            callback()
          }
        } else {
          callback(new Error(`请选择${endLable}`))
        }
      } else {
        callback()
      }
    } else {
      if (endTime) {
        if (startTime) {
          var a = (Date.parse(endTime) - Date.parse(startTime)) / 3600 / 1000
          if (a < 0) {
            callback(new Error(`${endLable}必须大于${startLable}`))
          } else {
            callback()
          }
        } else {
          callback(new Error(`请选择${startLable}`))
        }
      } else {
        callback()
      }
    }
  }
}

/**
 * @description: 时间判断 是否必填
 * @Author: baoxuhui
 * @param { Object } rule
 * @param { String } value
 * @param { Function } callback
 * @param { String } refName  ref 名称
 * @return {*}
 */
export function wangEitorFun(rule, value, callback, refName) {
  this.$nextTick(()=>{
    if (rule.required) {
      value = this.$refs[refName].getHtml()
      if (value) {
        callback()
      } else {
        callback(new Error(`请输入${rule.msg}`))
      }
    } else {
      callback()
    }
  })

}
